home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / symtable.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  11KB  |  313 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. """Interface to the compiler's internal symbol tables"""
  5. import _symtable
  6. from _symtable import USE, DEF_GLOBAL, DEF_LOCAL, DEF_PARAM, DEF_STAR, DEF_DOUBLESTAR, DEF_INTUPLE, DEF_FREE, DEF_FREE_GLOBAL, DEF_FREE_CLASS, DEF_IMPORT, DEF_BOUND, OPT_IMPORT_STAR, OPT_EXEC, OPT_BARE_EXEC
  7. import weakref
  8. __all__ = [
  9.     'symtable',
  10.     'SymbolTable',
  11.     'newSymbolTable',
  12.     'Class',
  13.     'Function',
  14.     'Symbol']
  15.  
  16. def symtable(code, filename, compile_type):
  17.     raw = _symtable.symtable(code, filename, compile_type)
  18.     return newSymbolTable(raw[0], filename)
  19.  
  20.  
  21. class SymbolTableFactory:
  22.     
  23.     def __init__(self):
  24.         self._SymbolTableFactory__memo = weakref.WeakValueDictionary()
  25.  
  26.     
  27.     def new(self, table, filename):
  28.         if table.type == _symtable.TYPE_FUNCTION:
  29.             return Function(table, filename)
  30.         
  31.         if table.type == _symtable.TYPE_CLASS:
  32.             return Class(table, filename)
  33.         
  34.         return SymbolTable(table, filename)
  35.  
  36.     
  37.     def __call__(self, table, filename):
  38.         key = (table, filename)
  39.         obj = self._SymbolTableFactory__memo.get(key, None)
  40.         if obj is None:
  41.             obj = self._SymbolTableFactory__memo[key] = self.new(table, filename)
  42.         
  43.         return obj
  44.  
  45.  
  46. newSymbolTable = SymbolTableFactory()
  47.  
  48. def is_free(flags):
  49.     if flags & (USE | DEF_FREE) and flags & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL):
  50.         return True
  51.     
  52.     if flags & DEF_FREE_CLASS:
  53.         return True
  54.     
  55.     return False
  56.  
  57.  
  58. class SymbolTable:
  59.     
  60.     def __init__(self, raw_table, filename):
  61.         self._table = raw_table
  62.         self._filename = filename
  63.         self._symbols = { }
  64.  
  65.     
  66.     def __repr__(self):
  67.         if self.__class__ == SymbolTable:
  68.             kind = ''
  69.         else:
  70.             kind = '%s ' % self.__class__.__name__
  71.         if self._table.name == 'global':
  72.             return '<%sSymbolTable for module %s>' % (kind, self._filename)
  73.         else:
  74.             return '<%sSymbolTable for %s in %s>' % (kind, self._table.name, self._filename)
  75.  
  76.     
  77.     def get_type(self):
  78.         if self._table.type == _symtable.TYPE_MODULE:
  79.             return 'module'
  80.         
  81.         if self._table.type == _symtable.TYPE_FUNCTION:
  82.             return 'function'
  83.         
  84.         if self._table.type == _symtable.TYPE_CLASS:
  85.             return 'class'
  86.         
  87.  
  88.     
  89.     def get_id(self):
  90.         return self._table.id
  91.  
  92.     
  93.     def get_name(self):
  94.         return self._table.name
  95.  
  96.     
  97.     def get_lineno(self):
  98.         return self._table.lineno
  99.  
  100.     
  101.     def is_optimized(self):
  102.         if self._table.type == _symtable.TYPE_FUNCTION:
  103.             pass
  104.         return bool(not (self._table.optimized))
  105.  
  106.     
  107.     def is_nested(self):
  108.         return bool(self._table.nested)
  109.  
  110.     
  111.     def has_children(self):
  112.         return bool(self._table.children)
  113.  
  114.     
  115.     def has_exec(self):
  116.         '''Return true if the scope uses exec'''
  117.         return bool(self._table.optimized & (OPT_EXEC | OPT_BARE_EXEC))
  118.  
  119.     
  120.     def has_import_star(self):
  121.         '''Return true if the scope uses import *'''
  122.         return bool(self._table.optimized & OPT_IMPORT_STAR)
  123.  
  124.     
  125.     def get_identifiers(self):
  126.         return self._table.symbols.keys()
  127.  
  128.     
  129.     def lookup(self, name):
  130.         sym = self._symbols.get(name)
  131.         if sym is None:
  132.             flags = self._table.symbols[name]
  133.             namespaces = self._SymbolTable__check_children(name)
  134.             sym = self._symbols[name] = Symbol(name, flags, namespaces)
  135.         
  136.         return sym
  137.  
  138.     
  139.     def get_symbols(self):
  140.         return [ self.lookup(ident) for ident in self.get_identifiers() ]
  141.  
  142.     
  143.     def __check_children(self, name):
  144.         return _[1]
  145.  
  146.     
  147.     def get_children(self):
  148.         return [ newSymbolTable(st, self._filename) for st in self._table.children ]
  149.  
  150.  
  151.  
  152. class Function(SymbolTable):
  153.     __params = None
  154.     __locals = None
  155.     __frees = None
  156.     __globals = None
  157.     
  158.     def __idents_matching(self, test_func):
  159.         return [](_[1])
  160.  
  161.     
  162.     def get_parameters(self):
  163.         if self._Function__params is None:
  164.             self._Function__params = self._Function__idents_matching((lambda x: x & DEF_PARAM))
  165.         
  166.         return self._Function__params
  167.  
  168.     
  169.     def get_locals(self):
  170.         if self._Function__locals is None:
  171.             self._Function__locals = self._Function__idents_matching((lambda x: x & DEF_BOUND))
  172.         
  173.         return self._Function__locals
  174.  
  175.     
  176.     def get_globals(self):
  177.         if self._Function__globals is None:
  178.             glob = DEF_GLOBAL | DEF_FREE_GLOBAL
  179.             self._Function__globals = self._Function__idents_matching((lambda x: x & glob))
  180.         
  181.         return self._Function__globals
  182.  
  183.     
  184.     def get_frees(self):
  185.         if self._Function__frees is None:
  186.             self._Function__frees = self._Function__idents_matching(is_free)
  187.         
  188.         return self._Function__frees
  189.  
  190.  
  191.  
  192. class Class(SymbolTable):
  193.     __methods = None
  194.     
  195.     def get_methods(self):
  196.         if self._Class__methods is None:
  197.             d = { }
  198.             for st in self._table.children:
  199.                 d[st.name] = 1
  200.             
  201.             self._Class__methods = tuple(d)
  202.         
  203.         return self._Class__methods
  204.  
  205.  
  206.  
  207. class Symbol:
  208.     
  209.     def __init__(self, name, flags, namespaces = None):
  210.         self._Symbol__name = name
  211.         self._Symbol__flags = flags
  212.         if not namespaces:
  213.             pass
  214.         self._Symbol__namespaces = ()
  215.  
  216.     
  217.     def __repr__(self):
  218.         return "<symbol '%s'>" % self._Symbol__name
  219.  
  220.     
  221.     def get_name(self):
  222.         return self._Symbol__name
  223.  
  224.     
  225.     def is_referenced(self):
  226.         return bool(self._Symbol__flags & _symtable.USE)
  227.  
  228.     
  229.     def is_parameter(self):
  230.         return bool(self._Symbol__flags & DEF_PARAM)
  231.  
  232.     
  233.     def is_global(self):
  234.         if not self._Symbol__flags & DEF_GLOBAL:
  235.             pass
  236.         return bool(self._Symbol__flags & DEF_FREE_GLOBAL)
  237.  
  238.     
  239.     def is_vararg(self):
  240.         return bool(self._Symbol__flags & DEF_STAR)
  241.  
  242.     
  243.     def is_keywordarg(self):
  244.         return bool(self._Symbol__flags & DEF_DOUBLESTAR)
  245.  
  246.     
  247.     def is_local(self):
  248.         return bool(self._Symbol__flags & DEF_BOUND)
  249.  
  250.     
  251.     def is_free(self):
  252.         if self._Symbol__flags & (USE | DEF_FREE) and self._Symbol__flags & (DEF_LOCAL | DEF_PARAM | DEF_GLOBAL):
  253.             return True
  254.         
  255.         if self._Symbol__flags & DEF_FREE_CLASS:
  256.             return True
  257.         
  258.         return False
  259.  
  260.     
  261.     def is_imported(self):
  262.         return bool(self._Symbol__flags & DEF_IMPORT)
  263.  
  264.     
  265.     def is_assigned(self):
  266.         return bool(self._Symbol__flags & DEF_LOCAL)
  267.  
  268.     
  269.     def is_in_tuple(self):
  270.         return bool(self._Symbol__flags & DEF_INTUPLE)
  271.  
  272.     
  273.     def is_namespace(self):
  274.         '''Returns true if name binding introduces new namespace.
  275.  
  276.         If the name is used as the target of a function or class
  277.         statement, this will be true.
  278.  
  279.         Note that a single name can be bound to multiple objects.  If
  280.         is_namespace() is true, the name may also be bound to other
  281.         objects, like an int or list, that does not introduce a new
  282.         namespace.
  283.         '''
  284.         return bool(self._Symbol__namespaces)
  285.  
  286.     
  287.     def get_namespaces(self):
  288.         '''Return a list of namespaces bound to this name'''
  289.         return self._Symbol__namespaces
  290.  
  291.     
  292.     def get_namespace(self):
  293.         '''Returns the single namespace bound to this name.
  294.  
  295.         Raises ValueError if the name is bound to multiple namespaces.
  296.         '''
  297.         if len(self._Symbol__namespaces) != 1:
  298.             raise ValueError, 'name is bound to multiple namespaces'
  299.         
  300.         return self._Symbol__namespaces[0]
  301.  
  302.  
  303. if __name__ == '__main__':
  304.     import os
  305.     import sys
  306.     src = open(sys.argv[0]).read()
  307.     mod = symtable(src, os.path.split(sys.argv[0])[1], 'exec')
  308.     for ident in mod.get_identifiers():
  309.         info = mod.lookup(ident)
  310.         print info, info.is_local(), info.is_namespace()
  311.     
  312.  
  313.